import type { 
  ChatEvent, 
  MessageEvent, 
  MessageEndEvent, 
  TtsMessageEvent, 
  TtsMessageEndEvent,
  MessageReplaceEvent,
  ErrorEvent,
} from '../types/chat';
import { logger } from '../utils/logger';

// 事件处理器类型
export type EventHandler<T = any> = (event: T) => void;

/**
 * 事件流处理服务
 */
export class EventStreamService {
  private messageHandler?: EventHandler<MessageEvent>;
  private messageEndHandler?: EventHandler<MessageEndEvent>;
  private ttsMessageHandler?: EventHandler<TtsMessageEvent>;
  private ttsMessageEndHandler?: EventHandler<TtsMessageEndEvent>;
  private messageReplaceHandler?: EventHandler<MessageReplaceEvent>;
  private errorHandler?: EventHandler<ErrorEvent>;
  private pingHandler?: EventHandler;

  /**
   * 构造函数
   */
  constructor() {}

  /**
   * 处理事件流数据
   * @param response 响应数据
   */
  async processEventStream(response: Response): Promise<void> {
    if (!response.body) {
      this.handleError(new Error('响应体为空'));
      return;
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = '';
    
    try {
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        
        buffer += decoder.decode(value, { stream: true });
        
        // 处理缓冲区中的每一行
        const lines = buffer.split('\n');
        buffer = lines.pop() || ''; // 保留最后一行（可能不完整）
        
        for (const line of lines) {
          if (line.trim() === '') continue;
          if (!line.startsWith('data:')) continue;
          
          // 提取JSON部分
          const jsonText = line.slice(5).trim();
          this.processEventLine(jsonText);
        }
      }
      
      // 处理残留在缓冲区的内容
      if (buffer.trim() !== '') {
        const lines = buffer.split('\n');
        for (const line of lines) {
          if (line.trim() === '' || !line.startsWith('data:')) continue;
          this.processEventLine(line.slice(5).trim());
        }
      }
      
    } catch (error) {
      this.handleError(error instanceof Error ? error : new Error('未知错误'));
    }
  }

  /**
   * 处理单行事件数据
   * @param jsonText JSON文本
   */
  private processEventLine(jsonText: string): void {
    if (!jsonText) return;
    
    try {
      // 尝试解析JSON
      const data = JSON.parse(jsonText);
      
      // 添加调试输出，查看实际的JSON数据
      logger.debug('EventStream', '收到的原始事件数据:', data);
      
      // 确定事件类型 - 可能通过event字段或根据其他字段判断
      let eventType = data.event;
      
      // 如果没有明确的event字段,尝试根据字段特征判断
      if (!eventType) {
        if (data.answer !== undefined && (data.id || data.message_id)) {
          eventType = 'message';
        } else if (data.metadata && data.message_id) {
          eventType = 'message_end';
        } else if (data.audio && data.message_id) {
          eventType = 'tts_message';
        } else if (data.event === '' && data.message_id) {
          eventType = 'tts_message_end';
        }
      }
      
      // 根据事件类型分发处理
      switch (eventType) {
        case 'message':
          // 严格按照MessageEvent类型处理
          if (typeof data.message_id === 'string' && 
              typeof data.task_id === 'string' && 
              typeof data.answer === 'string' && 
              typeof data.created_at === 'number') {
            const messageEvent: MessageEvent = {
              event: 'message',
              message_id: data.message_id,
              task_id: data.task_id,
              answer: data.answer,
              created_at: data.created_at
            };
            this.messageHandler?.(messageEvent);
          } else {
            logger.error('EventStream', 'Invalid message event data:', data);
          }
          break;
        
        case 'message_end':
          // 严格按照MessageEndEvent类型处理
          if (typeof data.message_id === 'string' && 
              typeof data.task_id === 'string' && 
              data.metadata && 
              typeof data.metadata.usage === 'object') {
            const messageEndEvent: MessageEndEvent = {
              event: 'message_end',
              message_id: data.message_id,
              task_id: data.task_id,
              metadata: {
                usage: data.metadata.usage,
                retriever_resources: data.metadata.retriever_resources
              }
            };
            this.messageEndHandler?.(messageEndEvent);
          } else {
            logger.error('EventStream', 'Invalid message end event data:', data);
          }
          break;
        
        case 'tts_message':
          if (typeof data.message_id === 'string' && 
              typeof data.task_id === 'string' && 
              typeof data.audio === 'string') {
            this.ttsMessageHandler?.({
              event: 'tts_message',
              message_id: data.message_id,
              task_id: data.task_id,
              audio: data.audio
            });
          } else {
            logger.error('EventStream', 'Invalid tts message event data:', data);
          }
          break;
        
        case 'tts_message_end':
          if (typeof data.message_id === 'string' && 
              typeof data.task_id === 'string') {
            this.ttsMessageEndHandler?.({
              event: 'tts_message_end',
              message_id: data.message_id,
              task_id: data.task_id
            });
          } else {
            logger.error('EventStream', 'Invalid tts message end event data:', data);
          }
          break;
        
        case 'message_replace':
          if (typeof data.message_id === 'string' && 
              typeof data.task_id === 'string' && 
              typeof data.answer === 'string') {
            this.messageReplaceHandler?.({
              event: 'message_replace',
              message_id: data.message_id,
              task_id: data.task_id,
              answer: data.answer
            });
          } else {
            logger.error('EventStream', 'Invalid message replace event data:', data);
          }
          break;
        
        case 'error':
          if (typeof data.message_id === 'string' && 
              typeof data.task_id === 'string' && 
              typeof data.message === 'string') {
            this.errorHandler?.({
              event: 'error',
              message_id: data.message_id,
              task_id: data.task_id,
              message: data.message
            });
          } else {
            logger.error('EventStream', 'Invalid error event data:', data);
          }
          break;
        
        case 'ping':
          this.pingHandler?.(data);
          break;
        
        default:
          logger.debug('EventStream', '未处理的事件类型:', { type: eventType || '未知', data });
          break;
      }
    } catch (error) {
      // JSON解析错误处理
      logger.error('EventStream', 'JSON解析失败:', error);
      
      // 处理特殊情况：截断的JSON
      this.handleTruncatedJson(jsonText, error);
    }
  }

  /**
   * 处理截断的JSON数据
   * @param jsonText JSON文本
   * @param parseError 解析错误
   */
  private handleTruncatedJson(jsonText: string, parseError: unknown): void {
    logger.error('EventStream', 'JSON解析失败:', parseError);
    logger.error('EventStream', '原始JSON数据:', jsonText);
    
    // 直接抛出错误，让上层处理
    throw new Error('JSON解析失败: ' + (parseError instanceof Error ? parseError.message : '未知错误'));
  }

  /**
   * 处理错误
   * @param error 错误对象
   */
  private handleError(error: Error): void {
    logger.error('EventStream', '事件流处理错误:', error);
    
    if (this.errorHandler) {
      const errorEvent: ErrorEvent = {
        event: 'error',
        message: error.message,
        task_id: '',
        message_id: ''
      };
      this.errorHandler(errorEvent);
    }
  }

  /**
   * 注册消息事件处理器
   * @param handler 处理函数
   */
  onMessage(handler: EventHandler<MessageEvent>): void {
    this.messageHandler = handler;
  }

  /**
   * 注册消息结束事件处理器
   * @param handler 处理函数
   */
  onMessageEnd(handler: EventHandler<MessageEndEvent>): void {
    this.messageEndHandler = handler;
  }

  /**
   * 注册语音消息事件处理器
   * @param handler 处理函数
   */
  onTtsMessage(handler: EventHandler<TtsMessageEvent>): void {
    this.ttsMessageHandler = handler;
  }

  /**
   * 注册语音消息结束事件处理器
   * @param handler 处理函数
   */
  onTtsMessageEnd(handler: EventHandler<TtsMessageEndEvent>): void {
    this.ttsMessageEndHandler = handler;
  }

  /**
   * 注册消息替换事件处理器
   * @param handler 处理函数
   */
  onMessageReplace(handler: EventHandler<MessageReplaceEvent>): void {
    this.messageReplaceHandler = handler;
  }

  /**
   * 注册错误事件处理器
   * @param handler 处理函数
   */
  onError(handler: EventHandler<ErrorEvent>): void {
    this.errorHandler = handler;
  }

  /**
   * 注册心跳事件处理器
   * @param handler 处理函数
   */
  onPing(handler: EventHandler): void {
    this.pingHandler = handler;
  }
} 